/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.apache.sanselan.formats.tiff;

/*import java.awt.Dimension;
import java.awt.image.BufferedImage;
import java.io.File;*/
import java.io.IOException;
/*import java.io.OutputStream;
import java.io.PrintWriter;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;*/
//import exifwriter.ArrayList;
//import de.enough.polish.util.Map;
import j2me.util.*;

import org.apache.sanselan.FormatCompliance;
import org.apache.sanselan.ImageFormat;
//import org.apache.sanselan.ImageInfo;
import org.apache.sanselan.ImageParser;
import org.apache.sanselan.ImageReadException;
import org.apache.sanselan.ImageWriteException;
import org.apache.sanselan.common.IImageMetadata;
import org.apache.sanselan.common.byteSources.ByteSource;
import org.apache.sanselan.formats.tiff.constants.TiffConstants;
/*import org.apache.sanselan.formats.tiff.datareaders.DataReader;
import org.apache.sanselan.formats.tiff.photometricinterpreters.PhotometricInterpreter;
import org.apache.sanselan.formats.tiff.photometricinterpreters.PhotometricInterpreterBiLevel;
import org.apache.sanselan.formats.tiff.photometricinterpreters.PhotometricInterpreterCIELAB;
import org.apache.sanselan.formats.tiff.photometricinterpreters.PhotometricInterpreterCMYK;
import org.apache.sanselan.formats.tiff.photometricinterpreters.PhotometricInterpreterLogLUV;
import org.apache.sanselan.formats.tiff.photometricinterpreters.PhotometricInterpreterPalette;
import org.apache.sanselan.formats.tiff.photometricinterpreters.PhotometricInterpreterRGB;
import org.apache.sanselan.formats.tiff.photometricinterpreters.PhotometricInterpreterYCbCr;*/
import org.apache.sanselan.formats.tiff.write.TiffImageWriterLossy;

public class TiffImageParser extends ImageParser implements TiffConstants
{
	public TiffImageParser()
	{
		// setDebug(true);
	}

	public String getName()
	{
		return "Tiff-Custom";
	}

	public String getDefaultExtension()
	{
		return DEFAULT_EXTENSION;
	}

	private static final String DEFAULT_EXTENSION = ".tif";

	private static final String ACCEPTED_EXTENSIONS[] = { ".tif", ".tiff", };

	protected String[] getAcceptedExtensions()
	{
		return ACCEPTED_EXTENSIONS;
	}

	protected ImageFormat[] getAcceptedTypes()
	{
		return new ImageFormat[] { ImageFormat.IMAGE_FORMAT_TIFF, //
		};
	}
/*Anup
	public byte[] getICCProfileBytes(ByteSource byteSource, Map params)
			throws ImageReadException, IOException
	{
		FormatCompliance formatCompliance = FormatCompliance.getDefault();
		TiffContents contents = new TiffReader(isStrict(params))
				.readFirstDirectory(byteSource, params, false, formatCompliance);
		TiffDirectory directory = (TiffDirectory) contents.directories.get(0);

		TiffField field = directory.findField(EXIF_TAG_ICC_PROFILE);
		if (null == field)
			return null;
		return field.oversizeValue;
	}

	public Dimension getImageSize(ByteSource byteSource, Map params)
			throws ImageReadException, IOException
	{
		FormatCompliance formatCompliance = FormatCompliance.getDefault();
		TiffContents contents = new TiffReader(isStrict(params))
				.readFirstDirectory(byteSource, params, false, formatCompliance);
		TiffDirectory directory = (TiffDirectory) contents.directories.get(0);

		int width = directory.findField(TIFF_TAG_IMAGE_WIDTH).getIntValue();
		int height = directory.findField(TIFF_TAG_IMAGE_LENGTH).getIntValue();

		return new Dimension(width, height);
	}

	public byte[] embedICCProfile(byte image[], byte profile[])
	{
		return null;
	}

	public boolean embedICCProfile(File src, File dst, byte profile[])
	{
		return false;
	}
*/
	public IImageMetadata getMetadata(ByteSource byteSource, Map params)
			throws ImageReadException, IOException
	{
		FormatCompliance formatCompliance = FormatCompliance.getDefault();
		TiffContents contents = new TiffReader(isStrict(params)).readContents(
				byteSource, params, formatCompliance);

		ArrayList directories = contents.directories;

		TiffImageMetadata result = new TiffImageMetadata(contents);

		for (int i = 0; i < directories.size(); i++)
		{
			TiffDirectory dir = (TiffDirectory) directories.get(i);

			TiffImageMetadata.Directory metadataDirectory = new TiffImageMetadata.Directory(
					dir);

			ArrayList entries = dir.getDirectoryEntrys();

			for (int j = 0; j < entries.size(); j++)
			{
				TiffField entry = (TiffField) entries.get(j);
				metadataDirectory.add(entry);
			}

			result.add(metadataDirectory);
		}

		return result;
	}
/*Anup
	public ImageInfo getImageInfo(ByteSource byteSource, Map params)
			throws ImageReadException, IOException
	{
		FormatCompliance formatCompliance = FormatCompliance.getDefault();
		TiffContents contents = new TiffReader(isStrict(params))
				.readDirectories(byteSource, false, formatCompliance);
		TiffDirectory directory = (TiffDirectory) contents.directories.get(0);

		TiffField widthField = directory.findField(TIFF_TAG_IMAGE_WIDTH, true);
		TiffField heightField = directory
				.findField(TIFF_TAG_IMAGE_LENGTH, true);

		if ((widthField == null) || (heightField == null))
			throw new ImageReadException("TIFF image missing size info.");

		int height = heightField.getIntValue();
		int width = widthField.getIntValue();

		// -------------------

		TiffField resolutionUnitField = directory
				.findField(TIFF_TAG_RESOLUTION_UNIT);
		int resolutionUnit = 2; // Inch
		if ((resolutionUnitField != null)
				&& (resolutionUnitField.getValue() != null))
			resolutionUnit = resolutionUnitField.getIntValue();

		double unitsPerInch = -1;
		switch (resolutionUnit)
		{
		case 1:
			break;
		case 2: // Inch
			unitsPerInch = 1.0;
			break;
		case 3: // Meter
			unitsPerInch = 0.0254;
			break;
		default:
			break;

		}
		TiffField xResolutionField = directory.findField(TIFF_TAG_XRESOLUTION);
		TiffField yResolutionField = directory.findField(TIFF_TAG_YRESOLUTION);

		int physicalWidthDpi = -1;
		float physicalWidthInch = -1;
		int physicalHeightDpi = -1;
		float physicalHeightInch = -1;

		if (unitsPerInch > 0)
		{
			if ((xResolutionField != null)
					&& (xResolutionField.getValue() != null))
			{
				double XResolutionPixelsPerUnit = xResolutionField
						.getDoubleValue();
				physicalWidthDpi = (int) (XResolutionPixelsPerUnit / unitsPerInch);
				physicalWidthInch = (float) (width / (XResolutionPixelsPerUnit * unitsPerInch));
			}
			if ((yResolutionField != null)
					&& (yResolutionField.getValue() != null))
			{
				double YResolutionPixelsPerUnit = yResolutionField
						.getDoubleValue();
				physicalHeightDpi = (int) (YResolutionPixelsPerUnit / unitsPerInch);
				physicalHeightInch = (float) (height / (YResolutionPixelsPerUnit * unitsPerInch));
			}
		}

		// -------------------

		TiffField bitsPerSampleField = directory
				.findField(TIFF_TAG_BITS_PER_SAMPLE);

		int bitsPerSample = -1;
		if ((bitsPerSampleField != null)
				&& (bitsPerSampleField.getValue() != null))
			bitsPerSample = bitsPerSampleField.getIntValueOrArraySum();

		int bitsPerPixel = bitsPerSample; // assume grayscale;
		// dunno if this handles colormapped images correctly.

		// -------------------

		ArrayList comments = new ArrayList();
		ArrayList entries = directory.entries;
		for (int i = 0; i < entries.size(); i++)
		{
			TiffField field = (TiffField) entries.get(i);
			String comment = field.toString();
			comments.add(comment);
		}

		ImageFormat format = ImageFormat.IMAGE_FORMAT_TIFF;
		String formatName = "TIFF Tag-based Image File Format";
		String mimeType = "image/tiff";
		int numberOfImages = contents.directories.size();
		// not accurate ... only reflects first
		boolean isProgressive = false;
		// is TIFF ever interlaced/progressive?

		String formatDetails = "Tiff v." + contents.header.tiffVersion;

		boolean isTransparent = false; // TODO: wrong
		boolean usesPalette = false;
		TiffField colorMapField = directory.findField(TIFF_TAG_COLOR_MAP);
		if (colorMapField != null)
			usesPalette = true;

		int colorType = ImageInfo.COLOR_TYPE_RGB;

		int compression = directory.findField(TIFF_TAG_COMPRESSION)
				.getIntValue();
		String compressionAlgorithm;

		switch (compression)
		{
		case TIFF_COMPRESSION_UNCOMPRESSED_1:
			compressionAlgorithm = ImageInfo.COMPRESSION_ALGORITHM_NONE;
			break;
		case TIFF_COMPRESSION_CCITT_1D:
			compressionAlgorithm = ImageInfo.COMPRESSION_ALGORITHM_CCITT_1D;
			break;
		case TIFF_COMPRESSION_CCITT_GROUP_3:
			compressionAlgorithm = ImageInfo.COMPRESSION_ALGORITHM_CCITT_GROUP_3;
			break;
		case TIFF_COMPRESSION_CCITT_GROUP_4:
			compressionAlgorithm = ImageInfo.COMPRESSION_ALGORITHM_CCITT_GROUP_4;
			break;
		case TIFF_COMPRESSION_LZW:
			compressionAlgorithm = ImageInfo.COMPRESSION_ALGORITHM_LZW;
			break;
		case TIFF_COMPRESSION_JPEG:
			compressionAlgorithm = ImageInfo.COMPRESSION_ALGORITHM_JPEG;
			break;
		case TIFF_COMPRESSION_UNCOMPRESSED_2:
			compressionAlgorithm = ImageInfo.COMPRESSION_ALGORITHM_NONE;
			break;
		case TIFF_COMPRESSION_PACKBITS:
			compressionAlgorithm = ImageInfo.COMPRESSION_ALGORITHM_PACKBITS;
			break;
		default:
			compressionAlgorithm = ImageInfo.COMPRESSION_ALGORITHM_UNKNOWN;
			break;
		}

		ImageInfo result = new ImageInfo(formatDetails, bitsPerPixel, comments,
				format, formatName, height, mimeType, numberOfImages,
				physicalHeightDpi, physicalHeightInch, physicalWidthDpi,
				physicalWidthInch, width, isProgressive, isTransparent,
				usesPalette, colorType, compressionAlgorithm);

		return result;
	}

	public String getXmpXml(ByteSource byteSource, Map params)
			throws ImageReadException, IOException
	{
		FormatCompliance formatCompliance = FormatCompliance.getDefault();
		TiffContents contents = new TiffReader(isStrict(params))
				.readDirectories(byteSource, false, formatCompliance);
		TiffDirectory directory = (TiffDirectory) contents.directories.get(0);

		TiffField xmpField = directory.findField(TIFF_TAG_XMP, false);
		if (xmpField == null)
			return null;

		byte bytes[] = xmpField.getByteArrayValue();

		try
		{
			// segment data is UTF-8 encoded xml.
			String xml = new String(bytes, "utf-8");
			return xml;
		} catch (UnsupportedEncodingException e)
		{
			throw new ImageReadException("Invalid JPEG XMP Segment.");
		}
	}

	public boolean dumpImageFile(PrintWriter pw, ByteSource byteSource)
			throws ImageReadException, IOException
	{
		try
		{
			pw.println("tiff.dumpImageFile");

			{
				ImageInfo imageData = getImageInfo(byteSource);
				if (imageData == null)
					return false;

				imageData.toString(pw, "");
			}

			pw.println("");

			// try
			{
				FormatCompliance formatCompliance = FormatCompliance
						.getDefault();
				Map params = null;
				TiffContents contents = new TiffReader(true).readContents(
						byteSource, params, formatCompliance);

				ArrayList directories = contents.directories;

				if (directories == null)
					return false;

				for (int d = 0; d < directories.size(); d++)
				{
					TiffDirectory directory = (TiffDirectory) directories
							.get(d);

					ArrayList entries = directory.entries;

					if (entries == null)
						return false;

					// Debug.debug("directory offset", directory.offset);

					for (int i = 0; i < entries.size(); i++)
					{
						TiffField field = (TiffField) entries.get(i);

						field.dump(pw, d + "");
					}
				}

				pw.println("");
			}
			// catch (Exception e)
			// {
			// Debug.debug(e);
			// pw.println("");
			// return false;
			// }

			return true;
		} finally
		{
			pw.println("");
		}
	}

	public FormatCompliance getFormatCompliance(ByteSource byteSource)
			throws ImageReadException, IOException
	{
		FormatCompliance formatCompliance = FormatCompliance.getDefault();
		Map params = null;
		new TiffReader(isStrict(params)).readContents(byteSource, params,
				formatCompliance);
		return formatCompliance;
	}

	public List collectRawImageData(ByteSource byteSource, Map params)
			throws ImageReadException, IOException
	{
		FormatCompliance formatCompliance = FormatCompliance.getDefault();
		TiffContents contents = new TiffReader(isStrict(params))
				.readDirectories(byteSource, true, formatCompliance);

		List result = new ArrayList();
		for (int i = 0; i < contents.directories.size(); i++)
		{
			TiffDirectory directory = (TiffDirectory) contents.directories
					.get(i);
			List dataElements = directory.getTiffRawImageDataElements();
			for (int j = 0; j < dataElements.size(); j++)
			{
				TiffDirectory.ImageDataElement element = (TiffDirectory.ImageDataElement) dataElements
						.get(j);
				byte bytes[] = byteSource.getBlock(element.offset,
						element.length);
				result.add(bytes);
			}
		}
		return result;
	}

	public BufferedImage getBufferedImage(ByteSource byteSource, Map params)
			throws ImageReadException, IOException
	{
		FormatCompliance formatCompliance = FormatCompliance.getDefault();
		TiffContents contents = new TiffReader(isStrict(params))
				.readFirstDirectory(byteSource, params, true, formatCompliance);
		TiffDirectory directory = (TiffDirectory) contents.directories.get(0);
		BufferedImage result = directory.getTiffImage(params);
		if (null == result)
			throw new ImageReadException("TIFF does not contain an image.");
		return result;
	}

	 protected BufferedImage getBufferedImage(TiffDirectory directory, Map params)
			throws ImageReadException, IOException
	{
		ArrayList entries = directory.entries;

		if (entries == null)
			throw new ImageReadException("TIFF missing entries");

		int photometricInterpretation = directory.findField(
				TIFF_TAG_PHOTOMETRIC_INTERPRETATION, true).getIntValue();
		int compression = directory.findField(TIFF_TAG_COMPRESSION, true)
				.getIntValue();
		int width = directory.findField(TIFF_TAG_IMAGE_WIDTH, true)
				.getIntValue();
		int height = directory.findField(TIFF_TAG_IMAGE_LENGTH, true)
				.getIntValue();
		int samplesPerPixel = directory.findField(TIFF_TAG_SAMPLES_PER_PIXEL,
				true).getIntValue();
		int bitsPerSample[] = directory.findField(TIFF_TAG_BITS_PER_SAMPLE,
				true).getIntArrayValue();
		// TODO: why are we using bits per sample twice? because one is a sum.
		int bitsPerPixel = directory.findField(TIFF_TAG_BITS_PER_SAMPLE, true)
				.getIntValueOrArraySum();

		// int bitsPerPixel = getTagAsValueOrArraySum(entries,
		// TIFF_TAG_BITS_PER_SAMPLE);

		int predictor = -1;
		{
			// dumpOptionalNumberTag(entries, TIFF_TAG_FILL_ORDER);
			// dumpOptionalNumberTag(entries, TIFF_TAG_FREE_BYTE_COUNTS);
			// dumpOptionalNumberTag(entries, TIFF_TAG_FREE_OFFSETS);
			// dumpOptionalNumberTag(entries, TIFF_TAG_ORIENTATION);
			// dumpOptionalNumberTag(entries, TIFF_TAG_PLANAR_CONFIGURATION);
			TiffField predictorField = directory.findField(TIFF_TAG_PREDICTOR);
			if (null != predictorField)
				predictor = predictorField.getIntValueOrArraySum();
		}

		if (samplesPerPixel != bitsPerSample.length)
			throw new ImageReadException("Tiff: samplesPerPixel ("
					+ samplesPerPixel + ")!=fBitsPerSample.length ("
					+ bitsPerSample.length + ")");

		boolean hasAlpha = false;
		BufferedImage result = getBufferedImageFactory(params)
				.getColorBufferedImage(width, height, hasAlpha);

		PhotometricInterpreter photometricInterpreter = getPhotometricInterpreter(
				directory, photometricInterpretation, bitsPerPixel,
				bitsPerSample, predictor, samplesPerPixel, width, height);

		TiffImageData imageData = directory.getTiffImageData();

		DataReader dataReader = imageData.getDataReader(entries,
				photometricInterpreter, bitsPerPixel, bitsPerSample, predictor,
				samplesPerPixel, width, height, compression);

		dataReader.readImageData(result);

		photometricInterpreter.dumpstats();

		return result;
	}

	private PhotometricInterpreter getPhotometricInterpreter(
			TiffDirectory directory, int photometricInterpretation,
			int bitsPerPixel, int bitsPerSample[], int predictor,
			int samplesPerPixel, int width, int height) throws IOException,
			ImageReadException
	{
		switch (photometricInterpretation)
		{
		case 0:
		case 1:
			boolean invert = photometricInterpretation == 0;

			return new PhotometricInterpreterBiLevel(bitsPerPixel,
					samplesPerPixel, bitsPerSample, predictor, width, height,
					invert);
		case 3: // Palette
		{
			int colorMap[] = directory.findField(TIFF_TAG_COLOR_MAP, true)
					.getIntArrayValue();

			int expected_colormap_size = 3 * (1 << bitsPerPixel);

			if (colorMap.length != expected_colormap_size)
				throw new ImageReadException("Tiff: fColorMap.length ("
						+ colorMap.length + ")!=expected_colormap_size ("
						+ expected_colormap_size + ")");

			return new PhotometricInterpreterPalette(samplesPerPixel,
					bitsPerSample, predictor, width, height, colorMap);
		}
		case 2: // RGB
			return new PhotometricInterpreterRGB(samplesPerPixel,
					bitsPerSample, predictor, width, height);
		case 5: // CMYK
			return new PhotometricInterpreterCMYK(samplesPerPixel,
					bitsPerSample, predictor, width, height);
		case 6: //
		{
			double yCbCrCoefficients[] = directory.findField(
					TIFF_TAG_YCBCR_COEFFICIENTS, true).getDoubleArrayValue();

			int yCbCrPositioning[] = directory.findField(
					TIFF_TAG_YCBCR_POSITIONING, true).getIntArrayValue();
			int yCbCrSubSampling[] = directory.findField(
					TIFF_TAG_YCBCR_SUB_SAMPLING, true).getIntArrayValue();

			double referenceBlackWhite[] = directory.findField(
					TIFF_TAG_REFERENCE_BLACK_WHITE, true).getDoubleArrayValue();

			return new PhotometricInterpreterYCbCr(yCbCrCoefficients,
					yCbCrPositioning, yCbCrSubSampling, referenceBlackWhite,
					samplesPerPixel, bitsPerSample, predictor, width, height);
		}

		case 8:
			return new PhotometricInterpreterCIELAB(samplesPerPixel,
					bitsPerSample, predictor, width, height);

		case 32844:
		case 32845: {
			boolean yonly = (photometricInterpretation == 32844);
			return new PhotometricInterpreterLogLUV(samplesPerPixel,
					bitsPerSample, predictor, width, height, yonly);
		}

		default:
			throw new ImageReadException(
					"TIFF: Unknown fPhotometricInterpretation: "
							+ photometricInterpretation);
		}
	}

	 public void writeImage(BufferedImage src, OutputStream os, Map params)
			throws ImageWriteException, IOException
	{
		new TiffImageWriterLossy().writeImage(src, os, params);
	}*/

}
